home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / ghostscript / 8.64 / Resource / Init / gs_cmap.ps < prev    next >
Encoding:
Text File  |  2009-04-17  |  17.3 KB  |  550 lines
  1. %    Copyright (C) 1995, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_cmap.ps 8954 2008-08-08 04:22:38Z ray $
  17. % ProcSet for implementing CMap resources.
  18. % When this is run, systemdict is still writable.
  19.  
  20. % NOTE: Rearranged fonts are not implemented yet.
  21.  
  22. [
  23.    /CMERGE_DEBUG
  24.    /USE_CIDCHAR_AS_RANGE
  25. ] {dup where {pop pop} { currentdict exch //false def pop } ifelse} forall
  26.  
  27. % ---------------- Public operators ---------------- %
  28.  
  29. /.rewriteTempMapsNotDef {
  30.   %
  31.   % Before building .CodeMapData from .TempMaps,
  32.   % we need to replace dst type codes in the notdef map with the value 3,
  33.   % which corresponds to CODE_VALUE_NOTDEF, see gxfcmap.h .
  34.   %
  35.   CMAPDEBUG { (rewriting TempMapsNotDef\n) print flush } if
  36.   .TempMaps 2 get
  37.   dup length 0 gt {
  38.     0 get
  39.     CMAPDEBUG { (...original...\n) print flush } if
  40.     1 5 2 index length 1 sub {
  41.       { 1 index exch get 2 3 put } stopped
  42.       { CMAPDEBUG { (cannot rewrite\n) print flush } if }
  43.       { CMAPDEBUG { (rewrite\n) print flush } if } ifelse
  44.     } for
  45.   } if
  46.   pop
  47.   CMAPDEBUG { (...FINISHED...\n) print } if
  48. } bind def
  49.  
  50. /.composefontdict {        % <name> <cmap|cmapname> <fonts> composefont <name> <font_dict>
  51.   10 dict begin
  52.     /CMap 2 index dup type /dicttype ne { /CMap findresource } if def
  53.     /FDepVector 1 index cvlit def    % temporarily
  54.     /Encoding [ 0 1 FDepVector length 1 sub { } for ] def
  55.     /FontInfo 1 dict def % for .processToUnicode in pdf_font.ps .
  56.     /FDepVector [ 0 1 FDepVector length 1 sub {
  57.         % Stack: name cmap[name] fonts /FDepVector [ fonts... i
  58.       FDepVector 1 index get
  59.       dup type /dicttype ne {
  60.     dup /CIDFont resourcestatus {
  61.       pop pop /CIDFont
  62.     } {
  63.       /Font
  64.     } ifelse findresource
  65.       } if
  66.       exch CMap /FontMatrices get dup length 2 index gt {
  67.     exch get dup //null eq { pop } { makefont } ifelse
  68.       } {
  69.     pop pop
  70.       } ifelse
  71.     } for ] readonly def
  72.     /FMapType 9 def
  73.     /FontMatrix matrix def
  74.     /FontName 3 index def
  75.     CMap /WMode .knownget { /WMode exch def } if
  76.     /FontType 0 def
  77.   pop pop currentdict end 
  78. } bind odef
  79.  
  80. % composefont doesn't appear in CMap files -- it's documented in
  81. % the "PostScript Language Reference Manual Supplement".
  82. /composefont {        % <name> <cmap|cmapname> <fonts> composefont <font>
  83.   .composefontdict /Font defineresource
  84. } bind def
  85.  
  86. % ---------------- CMap operators ---------------- %
  87.  
  88. 40 dict begin
  89.  
  90. % Our internal .CodeMapData structure closely mirrors the structures
  91. % defined in gxfcmap.h (q.v.).  () indicate a string, [] indicate an array,
  92. % ? indicates a Boolean, # indicates an integer, {} for grouping.
  93. %    [[[(first) (last) ...]+]        % code space ranges
  94. %     [[(prefix) (key_size,?is_range,value_type,value_size) (keys...)
  95. %       {(values...) | [value ...]} #font_index ]+]    % code mappings
  96. %      ...]
  97. %     <<same>>        % notdef mappings
  98. %    ]
  99. % FontMatrices is the array of matrices defined by begin/endusematrix.
  100. % All of the arrays and strings are read-only after they have been built.
  101. %
  102. % Note that the code in zfcmap.c that constructs the C structures from
  103. % the PostScript structures has intimate knowledge of the above format.
  104.  
  105. % ****** NOTE: The code currently only handles "well-behaved" CMaps:
  106. %    - CID values only (no bfchars), 16-bit
  107. %    - Entries (both code space and map) must be sorted
  108. %    - Only the last byte must vary in each map range, except for
  109. %    the identity mapping
  110.  
  111. % ------ Font-level operators ------ %
  112.  
  113. /begincmap {        % - begincmap -
  114.   /.CodeMapData [[[]] [[]] [[]]] def
  115.   /FontMatrices [] def
  116.   /.FontIndex 0 def
  117.   /.TempMaps [20 dict 50 dict 50 dict] def
  118.   /CodeMap //null def        % for .buildcmap
  119. } bind def
  120.  
  121. /endcmap {        % - endcmap -
  122.   .rewriteTempMapsNotDef
  123.  
  124.   CMAPDEBUG {
  125.     2 (*** undefined charmap ***)
  126.     1 (*** defined charmap ***)
  127.     0 (*** code space ranges ***)
  128.     3 { =
  129.       .TempMaps exch get
  130.       0 1 2 index length 1 sub {
  131.         dup == (\t) print
  132.         1 index exch get ==
  133.       } for
  134.       pop
  135.     } repeat
  136.   } if
  137.   
  138.   /.CodeMapData dup load [ exch
  139.     .TempMaps aload pop begin begin begin 
  140.     {
  141.       [ exch aload pop
  142.         0 1 currentdict length 1 sub { 
  143.            currentdict exch get 
  144.         } for 
  145.       ]
  146.       end
  147.     } forall
  148.   ] .endmap def
  149.  
  150.   CMAPDEBUG {
  151.     (*** Content of .CodeMapData ***) =
  152.     0 .CodeMapData { exch dup == 1 add exch (\t) print == } forall
  153.     pop
  154.   } if
  155.  
  156.   currentdict /.TempMaps undef
  157.   /FontMatrices FontMatrices .endmap def
  158. } bind def
  159.  
  160. /.endmap {        % <map> .endmap <map>
  161.   dup type /arraytype eq {
  162.     % This might be a shared read-only array inherited via usecmap.
  163.     % Don't try to update its elements if this is the case.
  164.     dup wcheck {
  165.       0 1 2 index length 1 sub {
  166.     2 copy 2 copy get .endmap put pop
  167.       } for readonly
  168.     } if
  169.   } {
  170.     dup type /stringtype eq { readonly } if
  171.   } ifelse
  172. } bind def
  173.  
  174. /.appendmap {        % -mark- <elt> ... <array#> .appendmap -
  175.   .TempMaps exch get counttomark 1 add 1 roll
  176.   ] 1 index length exch put
  177. } bind def
  178.  
  179. /begincodespacerange {    % <count> begincodespacerange -
  180.   pop mark
  181. } bind def
  182.  
  183. /endcodespacerange {    % <code_lo> <code_hi> ... endcodespacerange -
  184.   0 .appendmap
  185. } bind def
  186.  
  187. /usecmap {        % <CMap_name> usecmap -
  188.   /CMap findresource dup
  189.         % Copy the top level of .CodeMapData
  190.   /.CodeMapData exch /.CodeMapData get copyarray def
  191.   /FontMatrices exch /FontMatrices get copyarray def
  192. } bind def
  193.  
  194. /usefont {        % <fontID> usefont -
  195.   /.FontIndex exch def
  196. } bind def
  197.  
  198. /beginusematrix {    % <fontID> beginusematrix -
  199.   FontMatrices wcheck not FontMatrices length 2 index le or {
  200.     FontMatrices length 1 index 1 add .max array
  201.     dup 0 FontMatrices putinterval
  202.     /FontMatrices exch def
  203.   } if
  204. } bind def
  205.  
  206. /endusematrix {        % <matrix> endusematrix -
  207.   FontMatrices 3 1 roll put
  208. } bind def
  209.  
  210. % ------ Rearranged font operators ------ %
  211.  
  212. /beginrearrangedfont {    % <font_name> <font*> beginrearrangedfont -
  213.   10 dict begin
  214.   /.FontNames exch def
  215.   /.FontName exch def
  216.   begincmap
  217. } bind def
  218. /endrearrangedfont {    % - endrearrangedfont -
  219.   (REARRANGED FONTS NOT IMPLEMENTED YET.) = flush
  220.   FontName .FontNames 0 get findfont end definefont pop
  221. } bind def
  222.  
  223. % ------ Character name/code selector operators ------ %
  224.  
  225. /beginbfchar {        % <count> beginbfchar -
  226.   pop mark
  227. } bind def
  228. /endbfchar {        % <code> <to_code|charname> ... endbfchar
  229.   counttomark 2 idiv {
  230.     counttomark -2 roll        % process in correct order
  231.     .addbfchar
  232.   } repeat 1 .appendmap
  233. } bind def
  234.  
  235. /beginbfrange {        % <count> beginbfrange -
  236.   pop mark
  237. } bind def
  238. /endbfrange {        % <code_lo> <code_hi> <to_code|(charname*)> ...
  239.             %   endbfrange -
  240.   counttomark 3 idiv {
  241.     counttomark -3 roll        % process in correct order
  242.     dup type dup /arraytype eq exch /packedarraytype eq or {
  243.             % Array value, split up.
  244.       exch pop {
  245.             % Stack: code to_code|charname
  246.     1 index exch .addbfchar
  247.             % Increment the code.  As noted above, we require
  248.             % that only the last byte vary, but we still must
  249.             % mask it after incrementing, in case the last
  250.             % value was 0xff.
  251.             % Stack: code prefix params key value fontindex
  252.     6 -1 roll dup length string copy
  253.     dup dup length 1 sub 2 copy get 1 add 255 and put
  254.       } forall pop
  255.     } {
  256.             % Single value, handle directly.
  257.       .addbfrange
  258.     } ifelse
  259.   } repeat 1 .appendmap
  260. } bind def
  261.  
  262. /.addbfchar {        % <code> <to_code|charname> .addbfchar
  263.             %   <prefix> <params> <key> <value> <font_index>
  264.   1 index exch .addbfrange
  265. } bind def
  266. /.addbfrange {        % <code_lo> <code_hi> <to_code|charname>
  267.             %   .addbfrange <<same as .addbfchar>>
  268.   4 string dup 3
  269.   3 index type /nametype eq {
  270.     2 index 2 1 put % dst = CODE_VALUE_GLYPH, see gxfcmap.h .
  271.     4 -1 roll 1 array astore 4 1 roll 4
  272.   } {
  273.     2 index 2 2 put % dst = CODE_VALUE_CHARS, see gxfcmap.h .
  274.     3 index length
  275.   } ifelse put
  276.             % Stack: code_lo code_hi value params
  277.   3 index 3 index eq {
  278.             % Single value.
  279.     3 -1 roll pop exch () exch
  280.   } {
  281.             % Range.
  282.     dup 0 1 put dup 1 1 put
  283.     4 2 roll
  284.     dup dup length 1 sub 0 exch getinterval 5 1 roll    % prefix
  285.             % Stack: prefix value params code_lo code_hi
  286.     2 { exch dup length 1 sub 1 getinterval } repeat concatstrings
  287.     3 -1 roll
  288.   } ifelse
  289.   .FontIndex
  290. } bind def
  291.  
  292. % ------ CID selector operators ------ %
  293.  
  294. /begincidchar {        % <count> begincidchar -
  295.   pop mark
  296. } bind def
  297. /endcidchar {        % <code> <cid> ... endcidchar -
  298.   1 .endmapchars
  299. } bind def
  300.  
  301. /begincidrange {    % <count> begincidrange -
  302.   pop mark
  303. } bind def
  304. /endcidrange {        % <code_lo> <code_hi> <cid_base> ... endcidrange -
  305.   1 .endmapranges
  306. } bind def
  307.  
  308. /.endmapchars {         % -mark- <code> <cid> ... <map#> .endmapchars -
  309.   counttomark 1 add 1 roll
  310.   counttomark 2 idiv {
  311.     counttomark -2 roll         % process in correct order
  312.     exch        % <cid> <code>
  313.                 % Construct prefix, params, key, value, font_index
  314.     dup length 1 eq {   % 1-byte
  315.       <00 00 00 02> ()  % <prefix> <param> <null_key>
  316.     } {                 % N-byte
  317.       dup 0 1 getinterval exch  % make 1-byte prefix
  318.       4 string dup 0
  319.       USE_CIDCHAR_AS_RANGE {
  320.         <00 01 00 02>   % skelton for param
  321.       } {
  322.         <00 00 00 02>   % skelton for param
  323.       } ifelse
  324.       putinterval
  325.       exch              % <prefix> <param> <code>
  326.       dup length        % <prefix> <param> <code> N
  327.       1 sub             % <prefix> <param> <code> N-1
  328.       dup               % <prefix> <param> <code> N-1 N-1
  329.       3 index           % <prefix> <param> <code> N-1 N-1 <param>
  330.       exch              % <prefix> <param> <code> N-1 <param> N-1
  331.       0 exch            % <prefix> <param> <code> N-1 <param> 0 N-1
  332.       put               % <prefix> <param'> <code> N-1
  333.       1 exch            % <prefix> <param'> <code> 1 N-1
  334.       getinterval       % <prefix> <param'> <key>
  335.  
  336.       USE_CIDCHAR_AS_RANGE {
  337.         dup length 2 mul string % <key> <dkey>
  338.         dup                     % <key> <dkey> <dkey>
  339.         2 index                 % <key> <dkey> <dkey> <key>
  340.         0 exch putinterval      % <key> <dkey'>
  341.         dup                     % <key> <dkey'> <dkey'>
  342.         3 -1 roll               % <dkey'> <dkey'> <key>
  343.         dup length              % <dkey'> <dkey'> <key> N-1
  344.         exch putinterval        % <dkey''>
  345.       } if
  346.  
  347.     } ifelse
  348.  
  349.     4 -1 roll           % <prefix> <param'> <key> <cid>
  350.     .endmapvalue        % <prefix> <param'> <key> <hex_cid> <font_idx>
  351.     % prefix params keys value fontindex
  352.     counttomark 5 gt { % 2 (or more) ranges (1 range = 5 item)
  353.        4 index 10 index eq      % compare prefix
  354.        4 index 10 index eq and  % compare params
  355.        1 index 7 index eq and   % compare fontindex
  356.         {
  357.           CMAPDEBUG { (merge! char\n) print } if
  358.           pop 4 2 roll pop pop
  359.            % prefix params keys value fontindex keys2 value2
  360.           5 -1 roll 3 -1 roll concatstrings
  361.            % prefix params value fontindex value2 keys'
  362.           4 -1 roll 3 -1 roll concatstrings
  363.            % prefix params fontindex keys' values'
  364.           3 -1 roll
  365.         } if
  366.      } if % end of 2 (or more) ranges
  367.     CMERGE_DEBUG {
  368.     ( prefix:) print 4 index =only
  369.     ( param:) print 3 index =only
  370.     ( key:) print 2 index =only
  371.     ( hex_cid:) print 1 index =only
  372.     ( font_idx:) print 0 index == flush
  373.     } if
  374.   } repeat
  375.   counttomark 2 add -1 roll .appendmap
  376. } bind def
  377.  
  378. /.endmapranges {    % -mark- <code_lo> <code_hi> <cid_base> ... <map#>
  379.             %   .endmapranges -
  380.   counttomark 1 add 1 roll
  381.   counttomark 3 idiv {
  382.     counttomark -3 roll        % process in correct order
  383.         % Construct prefix, params, key_lo, key_hi, value, font_index
  384.     3 1 roll    % <cid_base> <code_lo> <code_hi>
  385.         %        prefix    key
  386.         % 1-byte code:    ()    .
  387.         % 1-byte range:    ()    .
  388.         % N-byte code:    .    (*)
  389.         % N-byte range:    (*)    (*)
  390.     dup 2 index eq {    % <code_lo> == <code_hi>
  391.                    % 0: prefix_len for 1-byte code
  392.                    % 1: prefix_len for N-byte code
  393.        dup length 1 eq { 0 } { 1 } ifelse
  394.     } {            % <code_lo> != <code_hi>
  395.                  % calculate prefix_len for *-byte range
  396.        dup length 1 sub % <cid_base> <code_lo> <code_hi> <code_len-1>
  397.        0        % initial value for N
  398.        {        % <cid_base> <code_lo> <code_hi> (code_len-1)  N
  399.            dup 2 index ge { exit } if % if (N >= len - 1) exit
  400.            3 index 1 index get    % N-th byte of code_lo
  401.            3 index 2 index get    % N-th byte of code_hi
  402.            eq { 1 add } { exit } ifelse
  403.        } loop
  404.        exch pop     % discard <code_len-1>
  405.     } ifelse
  406.                 % cid_base code_lo code_hi prefix_len
  407.  
  408.     % Althogh Adobe CPSI with native CID/CMap support accept
  409.     % multi-dimensional range specification in notdef & cidrange
  410.     % (and CID is calculated as relative position in multi-dimensional
  411.     % range), but older CPSI & ATM cannot handle it.
  412.     % 
  413.     % GS accepts such specification, but it's recommended to keep
  414.     % from using this feature for notdef & cidrange.
  415.     % Following is a disabler of this feature.
  416.     % -------------------------------------------------------------
  417.     % counttomark 1 add index     % get map#
  418.     % 0 ne {            % if not codespacerange
  419.     %   1 index length         % get code length
  420.     %   1 index             % get prefix length
  421.     %   sub            % calculate key length
  422.     %   1 gt {            % if (key_len > 1),
  423.     %      (.endmapranges error) = flush
  424.     %      (multi-dimensional range specification is used out of codespacerange)
  425.     %      = flush
  426.     %      (/) =only
  427.     %      CMapName CMapName length string cvs =only
  428.     %      (: <) =only
  429.     %      2 index (%stdout) (w) file exch writehexstring
  430.     %      (> <) =only
  431.     %      1 index (%stdout) (w) file exch writehexstring
  432.     %      (>\n) =only flush
  433.     %      quit
  434.     %   } if
  435.     % } if
  436.     % -------------------------------------------------------------
  437.  
  438.     1 index exch 0 exch getinterval
  439.                 % cid_base code_lo code_hi prefix
  440.     dup length 3 index length exch sub
  441.                 % cid_base code_lo code_hi prefix range_len
  442.     dup 255 gt {
  443.        (too long coderange specification for current GS\n) print
  444.        /.endmapranges cvx /rangecheck signalerror
  445.     } if
  446.     <00 01 00 02> 4 string copy    % create initialized param
  447.     dup 0 4 -1 roll put        % put range_len into param
  448.  
  449.     % get key_hi
  450.     3 -1 roll dup length 3 index length dup 3 1 roll sub getinterval
  451.  
  452.     % get key_lo
  453.     4 -1 roll dup length 4 index length dup 3 1 roll sub getinterval
  454.  
  455.     % make "keys" (concatenated key_lo + key_hi)
  456.     exch concatstrings
  457.  
  458.     % 
  459.     4 -1 roll
  460.     .endmapvalue
  461.  
  462.         % See if we can merge with the previous value.
  463.         % The prefix, params, and font index must match.
  464.     % prefix params keys value fontindex
  465.     counttomark 5 gt { % 2 (or more) ranges (1 range = 5 item)
  466.        4 index 10 index eq    % compare prefix
  467.        4 index 10 index eq and    % compare params
  468.        1 index 7 index eq and    % compare fontindex
  469.     {
  470.           CMAPDEBUG { (merge!\n) print } if
  471.       pop 4 2 roll pop pop
  472.            % prefix params keys value fontindex keys2 value2
  473.       5 -1 roll 3 -1 roll concatstrings
  474.            % prefix params value fontindex value2 keys'
  475.       4 -1 roll 3 -1 roll concatstrings
  476.            % prefix params fontindex keys' values'
  477.       3 -1 roll
  478.     } if
  479.      } if % end of 2 (or more) ranges
  480.   } repeat
  481.   counttomark 2 add -1 roll .appendmap
  482. } bind def
  483.  
  484. /.endmapvalue {        % <cid> .endmapvalue (hi,lo) .FontIndex
  485.   2 string dup 0 3 index -8 bitshift put    % value
  486.   dup 1 4 -1 roll 255 and put
  487.   .FontIndex        % font_index
  488. } bind def
  489.  
  490. % ------ notdef operators ------ %
  491.  
  492. /beginnotdefchar {    % <count> beginnotdefchar -
  493.   pop mark
  494. } bind def
  495. /endnotdefchar {    % <code> <cid> ... endnotdefchar -
  496.   2 .endmapchars
  497. } bind def
  498.  
  499. /beginnotdefrange {    % <count> beginnotdefrange -
  500.   pop mark
  501. } bind def
  502. /endnotdefrange {    % <code_lo> <code_hi> <cid> ... endnotdefrange -
  503.   2 .endmapranges
  504. } bind def
  505.  
  506. % ---------------- Resource category definition ---------------- %
  507.  
  508. currentdict end
  509.  
  510. languagelevel exch 2 .setlanguagelevel
  511.  
  512. /CMap /Generic /Category findresource dup length dict .copydict
  513. dup /InstanceType /dicttype put
  514. dup /DefineResource {
  515.         % The AdobePS5 Windows driver emits code that attempts to
  516.         % create CMaps without the required CMapName entry.
  517.         % Work around this here.
  518.   dup /CMapName known not {
  519.     dup wcheck not {
  520.       .currentglobal exch dup wcheck .setglobal
  521.       dup length dict .copydict exch .setglobal
  522.     } if
  523.     dup gcheck 2 index gcheck not and {
  524.       exch .currentglobal exch //true .setglobal
  525.       dup length string copy exch .setglobal exch
  526.     } if dup /CMapName 3 index put
  527.   } if
  528.   % Adobe PS CET 23-25 and others define an almost empty CMap. Tolerate this.
  529.   % With the above, we can actually tolerate: /name << >> defineresource
  530.   dup /CIDSystemInfo known not {
  531.     dup wcheck not {
  532.       .currentglobal exch dup wcheck .setglobal
  533.       dup length dict .copydict exch .setglobal
  534.     } if
  535.     dup /CIDSystemInfo [ //null ] put
  536.   } if
  537.   dup /CodeMap .knownget { //null eq { .buildcmap } if } if
  538.   /Generic /Category findresource /DefineResource get exec
  539. } bind put
  540. /Category defineresource pop
  541.     % We might have loaded CID font support already.
  542. /CIDInit /ProcSet 2 copy { findresource } .internalstopped
  543.     % An interior `stopped' might have reset VM allocation to local.
  544. //true .setglobal
  545.  { pop pop 3 -1 roll }
  546.  { dup length 4 index length add dict .copydict 4 -1 roll exch .copydict }
  547. ifelse exch defineresource pop
  548.  
  549. .setlanguagelevel
  550.